package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern int nav_dtCrowd_addAgent(void * c_this,void * pos,void * params);
extern void nav_dtCrowd_Delete(void * c_this);
extern void nav_dtCrowd_DeleteArray(void * c_this);
extern void* nav_NewdtCrowd();
extern int nav_dtCrowd_getActiveAgents(void * c_this,void * agents,int maxAgents);
extern void * nav_dtCrowd_getAgent(void * c_this,int idx);
extern int nav_dtCrowd_getAgentCount(void * c_this);
extern void * nav_dtCrowd_getEditableAgent(void * c_this,int idx);
extern void * nav_dtCrowd_getEditableFilter(void * c_this,int i);
extern void * nav_dtCrowd_getFilter(void * c_this,int i);
extern void * nav_dtCrowd_getGrid(void * c_this);
extern void * nav_dtCrowd_getNavMeshQuery(void * c_this);
extern void * nav_dtCrowd_getObstacleAvoidanceParams(void * c_this,int idx);
extern void * nav_dtCrowd_getPathQueue(void * c_this);
extern void * nav_dtCrowd_getQueryExtents(void * c_this);
extern void * nav_dtCrowd_getQueryHalfExtents(void * c_this);
extern int nav_dtCrowd_getVelocitySampleCount(void * c_this);
extern void * nav_dtCrowd_IndexArray(void * c_this,long n);
extern bool nav_dtCrowd_init(void * c_this,int maxAgents,float maxAgentRadius,void * tmp_arg_nav);
extern void nav_dtCrowd_removeAgent(void * c_this,int idx);
extern bool nav_dtCrowd_requestMoveTarget(void * c_this,int idx,unsigned int ref,void * pos);
extern bool nav_dtCrowd_requestMoveVelocity(void * c_this,int idx,void * vel);
extern bool nav_dtCrowd_resetMoveTarget(void * c_this,int idx);
extern void nav_dtCrowd_setObstacleAvoidanceParams(void * c_this,int idx,void * params);
extern void nav_dtCrowd_update(void * c_this,float dt,void * debug);
extern void nav_dtCrowd_updateAgentParameters(void * c_this,int idx,void * params);
extern void nav_dtCrowdAgent_Delete(void * c_this);
extern void nav_dtCrowdAgent_DeleteArray(void * c_this);
extern void* nav_NewdtCrowdAgent();
extern void * nav_dtCrowdAgent_GetPtrToActive(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToBoundary(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToCornerFlags(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToCornerPolys(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToCornerVerts(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToCorridor(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToDesiredSpeed(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToDisp(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToDvel(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToNcorners(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToNeis(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToNneis(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToNpos(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToNvel(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToParams(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToPartial(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToState(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToTargetPathqRef(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToTargetPos(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToTargetRef(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToTargetReplan(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToTargetReplanTime(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToTargetState(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToTopologyOptTime(void * c_this);
extern void * nav_dtCrowdAgent_GetPtrToVel(void * c_this);
extern void * nav_dtCrowdAgent_IndexArray(void * c_this,long n);
extern void nav_dtCrowdAgentAnimation_Delete(void * c_this);
extern void nav_dtCrowdAgentAnimation_DeleteArray(void * c_this);
extern void* nav_NewdtCrowdAgentAnimation();
extern void * nav_dtCrowdAgentAnimation_GetPtrToActive(void * c_this);
extern void * nav_dtCrowdAgentAnimation_GetPtrToEndPos(void * c_this);
extern void * nav_dtCrowdAgentAnimation_GetPtrToInitPos(void * c_this);
extern void * nav_dtCrowdAgentAnimation_GetPtrToPolyRef(void * c_this);
extern void * nav_dtCrowdAgentAnimation_GetPtrToStartPos(void * c_this);
extern void * nav_dtCrowdAgentAnimation_GetPtrToT(void * c_this);
extern void * nav_dtCrowdAgentAnimation_GetPtrToTmax(void * c_this);
extern void * nav_dtCrowdAgentAnimation_IndexArray(void * c_this,long n);
extern void nav_dtCrowdAgentDebugInfo_Delete(void * c_this);
extern void nav_dtCrowdAgentDebugInfo_DeleteArray(void * c_this);
extern void* nav_NewdtCrowdAgentDebugInfo();
extern void * nav_dtCrowdAgentDebugInfo_GetPtrToIdx(void * c_this);
extern void * nav_dtCrowdAgentDebugInfo_GetPtrToOptEnd(void * c_this);
extern void * nav_dtCrowdAgentDebugInfo_GetPtrToOptStart(void * c_this);
extern void * nav_dtCrowdAgentDebugInfo_GetPtrToVod(void * c_this);
extern void * nav_dtCrowdAgentDebugInfo_IndexArray(void * c_this,long n);
extern void nav_dtCrowdAgentParams_Delete(void * c_this);
extern void nav_dtCrowdAgentParams_DeleteArray(void * c_this);
extern void* nav_NewdtCrowdAgentParams();
extern void * nav_dtCrowdAgentParams_GetPtrToCollisionQueryRange(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToHeight(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToMaxAcceleration(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToMaxSpeed(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToObstacleAvoidanceType(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToPathOptimizationRange(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToQueryFilterType(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToRadius(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToSeparationWeight(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToUpdateFlags(void * c_this);
extern void * nav_dtCrowdAgentParams_GetPtrToUserData(void * c_this);
extern void * nav_dtCrowdAgentParams_IndexArray(void * c_this,long n);
extern void nav_dtCrowdNeighbour_Delete(void * c_this);
extern void nav_dtCrowdNeighbour_DeleteArray(void * c_this);
extern void* nav_NewdtCrowdNeighbour();
extern void * nav_dtCrowdNeighbour_GetPtrToDist(void * c_this);
extern void * nav_dtCrowdNeighbour_GetPtrToIdx(void * c_this);
extern void * nav_dtCrowdNeighbour_IndexArray(void * c_this,long n);
extern void * nav_dtAllocCrowd();
extern void nav_dtFreeCrowd(void * ptr);
extern void * nav_NewDtCrowdAgentAnimationPtrArray(long n);
extern void * nav_NewDtCrowdAgentDebugInfoPtrArray(long n);
extern void * nav_NewDtCrowdAgentParamsPtrArray(long n);
extern void * nav_NewDtCrowdAgentPtrArray(long n);
extern void * nav_NewDtCrowdNeighbourPtrArray(long n);
extern void * nav_NewDtCrowdPtrArray(long n);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

/*
Provides local steering behaviors for a group of agents.

	crowd
*/
type DtCrowdPtr uintptr

/*
Adds a new agent to the crowd.

@param pos The requested position of the agent. [(x, y, z)]
@param params The configuration of the agent.
@return The index of the agent in the agent pool. Or -1 if the agent could not be added.

public int addAgent(float const * pos, dtCrowdAgentParams const * params)
*/
func (p DtCrowdPtr) AddAgent(pos *float32, params DtCrowdAgentParamsPtr) int32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_params unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_params = (unsafe.Pointer)(params)
	wrap_out := C.nav_dtCrowd_addAgent(wrap_this, wrap_arg_pos, wrap_arg_params)
	go_out := int32(wrap_out)
	return go_out
}

/*
public void Delete()
*/
func (p DtCrowdPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowd_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtCrowdPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowd_DeleteArray(wrap_this)
}

/*
public dtCrowd()
*/
func NewDtCrowd() cgo.GoManagedPtr[DtCrowdPtr] {
	wrap_out := C.nav_NewdtCrowd()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtCrowdPtr]](uintptr(wrap_out))
	return go_out
}

/*
Gets the active agents int the agent pool.

@param agents An array of agent pointers. [(#dtCrowdAgent *) * maxAgents]
@param maxAgents The size of the crowd agent array.
@return The number of agents returned in @p agents.

public int getActiveAgents(dtCrowdAgent * * agents, int const maxAgents)
*/
func (p DtCrowdPtr) GetActiveAgents(agents *DtCrowdAgentPtr, maxAgents int32) int32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_agents unsafe.Pointer
	var wrap_arg_maxAgents C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_agents = (unsafe.Pointer)(agents)
	wrap_arg_maxAgents = (C.int)(maxAgents)
	wrap_out := C.nav_dtCrowd_getActiveAgents(wrap_this, wrap_arg_agents, wrap_arg_maxAgents)
	go_out := int32(wrap_out)
	return go_out
}

/*
Gets the specified agent from the pool.

@param idx The agent index. [Limits: 0
<
= value
<
#getAgentCount()]
@return The requested agent.

public dtCrowdAgent const * getAgent(int const idx)
*/
func (p DtCrowdPtr) GetAgent(idx int32) DtCrowdAgentPtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_out := C.nav_dtCrowd_getAgent(wrap_this, wrap_arg_idx)
	go_out := cgo.MakePtr[DtCrowdAgentPtr](uintptr(wrap_out))
	return go_out
}

/*
The maximum number of agents that can be managed by the object.

@return The maximum number of agents.

public int getAgentCount() const
*/
func (p DtCrowdPtr) GetAgentCount() int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_getAgentCount(wrap_this)
	go_out := int32(wrap_out)
	return go_out
}

/*
Gets the specified agent from the pool.

@param idx The agent index. [Limits: 0
<
= value
<
#getAgentCount()]
@return The requested agent.

public dtCrowdAgent * getEditableAgent(int const idx)
*/
func (p DtCrowdPtr) GetEditableAgent(idx int32) DtCrowdAgentPtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_out := C.nav_dtCrowd_getEditableAgent(wrap_this, wrap_arg_idx)
	go_out := cgo.MakePtr[DtCrowdAgentPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the filter used by the crowd.

@return The filter used by the crowd.

public dtQueryFilter * getEditableFilter(int const i)
*/
func (p DtCrowdPtr) GetEditableFilter(i int32) DtQueryFilterPtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_i C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_i = (C.int)(i)
	wrap_out := C.nav_dtCrowd_getEditableFilter(wrap_this, wrap_arg_i)
	go_out := cgo.MakePtr[DtQueryFilterPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the filter used by the crowd.

@return The filter used by the crowd.

public dtQueryFilter const * getFilter(int const i) const
*/
func (p DtCrowdPtr) GetFilter(i int32) DtQueryFilterPtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_i C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_i = (C.int)(i)
	wrap_out := C.nav_dtCrowd_getFilter(wrap_this, wrap_arg_i)
	go_out := cgo.MakePtr[DtQueryFilterPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the crowd's proximity grid.

@return The crowd's proximity grid.

public dtProximityGrid const * getGrid() const
*/
func (p DtCrowdPtr) GetGrid() DtProximityGridPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_getGrid(wrap_this)
	go_out := cgo.MakePtr[DtProximityGridPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the query object used by the crowd.

public dtNavMeshQuery const * getNavMeshQuery() const
*/
func (p DtCrowdPtr) GetNavMeshQuery() DtNavMeshQueryPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_getNavMeshQuery(wrap_this)
	go_out := cgo.MakePtr[DtNavMeshQueryPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the shared avoidance configuration for the specified index.

@param idx The index of the configuration to retreive.
[Limits:  0
<
= value
<
#DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS]
@return The requested configuration.

public dtObstacleAvoidanceParams const * getObstacleAvoidanceParams(int const idx) const
*/
func (p DtCrowdPtr) GetObstacleAvoidanceParams(idx int32) DtObstacleAvoidanceParamsPtr {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_out := C.nav_dtCrowd_getObstacleAvoidanceParams(wrap_this, wrap_arg_idx)
	go_out := cgo.MakePtr[DtObstacleAvoidanceParamsPtr](uintptr(wrap_out))
	return go_out
}

/*
Gets the crowd's path request queue.

@return The crowd's path request queue.

public dtPathQueue const * getPathQueue() const
*/
func (p DtCrowdPtr) GetPathQueue() DtPathQueuePtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_getPathQueue(wrap_this)
	go_out := cgo.MakePtr[DtPathQueuePtr](uintptr(wrap_out))
	return go_out
}

/*
Same as getQueryHalfExtents. Left to maintain backwards compatibility.

@return The search halfExtents used by the crowd. [(x, y, z)]

public float const * getQueryExtents() const
*/
func (p DtCrowdPtr) GetQueryExtents() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_getQueryExtents(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Gets the search halfExtents [(x, y, z)] used by the crowd for query operations.

@return The search halfExtents used by the crowd. [(x, y, z)]

public float const * getQueryHalfExtents() const
*/
func (p DtCrowdPtr) GetQueryHalfExtents() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_getQueryHalfExtents(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Gets the velocity sample count.

@return The velocity sample count.

public int getVelocitySampleCount() const
*/
func (p DtCrowdPtr) GetVelocitySampleCount() int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_getVelocitySampleCount(wrap_this)
	go_out := int32(wrap_out)
	return go_out
}

/*
dtCrowd * IndexArray(long n)
*/
func (p DtCrowdPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowd_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Initializes the crowd.

@param maxAgents The maximum number of agents the crowd can manage. [Limit: >= 1]
@param maxAgentRadius The maximum radius of any agent that will be added to the crowd. [Limit: > 0]
@param nav The navigation mesh to use for planning.
@return True if the initialization succeeded.

public bool init(int const maxAgents, float const maxAgentRadius, dtNavMesh * tmp_arg_nav)
*/
func (p DtCrowdPtr) Init(maxAgents int32, maxAgentRadius float32, tmp_arg_nav DtNavMeshPtr) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_maxAgents C.int
	var wrap_arg_maxAgentRadius C.float
	var wrap_arg_tmp_arg_nav unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_maxAgents = (C.int)(maxAgents)
	wrap_arg_maxAgentRadius = (C.float)(maxAgentRadius)
	wrap_arg_tmp_arg_nav = (unsafe.Pointer)(tmp_arg_nav)
	wrap_out := C.nav_dtCrowd_init(wrap_this, wrap_arg_maxAgents, wrap_arg_maxAgentRadius, wrap_arg_tmp_arg_nav)
	go_out := bool(wrap_out)
	return go_out
}

/*
Removes the agent from the crowd.

@param idx The agent index. [Limits: 0
<
= value
<
#getAgentCount()]

public void removeAgent(int const idx)
*/
func (p DtCrowdPtr) RemoveAgent(idx int32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	C.nav_dtCrowd_removeAgent(wrap_this, wrap_arg_idx)
}

/*
Submits a new move request for the specified agent.

@param idx The agent index. [Limits: 0
<
= value
<
#getAgentCount()]
@param ref The position's polygon reference.
@param pos The position within the polygon. [(x, y, z)]
@return True if the request was successfully submitted.

public bool requestMoveTarget(int const idx, dtPolyRef ref, float const * pos)
*/
func (p DtCrowdPtr) RequestMoveTarget(idx int32, ref uint32, pos *float32) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	var wrap_arg_ref C.uint
	var wrap_arg_pos unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_arg_ref = (C.uint)(ref)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_out := C.nav_dtCrowd_requestMoveTarget(wrap_this, wrap_arg_idx, wrap_arg_ref, wrap_arg_pos)
	go_out := bool(wrap_out)
	return go_out
}

/*
Submits a new move request for the specified agent.

@param idx The agent index. [Limits: 0
<
= value
<
#getAgentCount()]
@param vel The movement velocity. [(x, y, z)]
@return True if the request was successfully submitted.

public bool requestMoveVelocity(int const idx, float const * vel)
*/
func (p DtCrowdPtr) RequestMoveVelocity(idx int32, vel *float32) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	var wrap_arg_vel unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_arg_vel = (unsafe.Pointer)(vel)
	wrap_out := C.nav_dtCrowd_requestMoveVelocity(wrap_this, wrap_arg_idx, wrap_arg_vel)
	go_out := bool(wrap_out)
	return go_out
}

/*
Resets any request for the specified agent.

@param idx The agent index. [Limits: 0
<
= value
<
#getAgentCount()]
@return True if the request was successfully reseted.

public bool resetMoveTarget(int const idx)
*/
func (p DtCrowdPtr) ResetMoveTarget(idx int32) bool {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_out := C.nav_dtCrowd_resetMoveTarget(wrap_this, wrap_arg_idx)
	go_out := bool(wrap_out)
	return go_out
}

/*
Sets the shared avoidance configuration for the specified index.

@param idx The index. [Limits: 0
<
= value
<
#DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS]
@param params The new configuration.

public void setObstacleAvoidanceParams(int const idx, dtObstacleAvoidanceParams const * params)
*/
func (p DtCrowdPtr) SetObstacleAvoidanceParams(idx int32, params DtObstacleAvoidanceParamsPtr) {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	var wrap_arg_params unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_arg_params = (unsafe.Pointer)(params)
	C.nav_dtCrowd_setObstacleAvoidanceParams(wrap_this, wrap_arg_idx, wrap_arg_params)
}

/*
Updates the steering and positions of all agents.

@param dt The time, in seconds, to update the simulation. [Limit: > 0]
@param debug A debug object to load with debug information. [Opt]

public void update(float const dt, dtCrowdAgentDebugInfo * debug)
*/
func (p DtCrowdPtr) Update(dt float32, debug DtCrowdAgentDebugInfoPtr) {
	var wrap_this unsafe.Pointer
	var wrap_arg_dt C.float
	var wrap_arg_debug unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_dt = (C.float)(dt)
	wrap_arg_debug = (unsafe.Pointer)(debug)
	C.nav_dtCrowd_update(wrap_this, wrap_arg_dt, wrap_arg_debug)
}

/*
Updates the specified agent's configuration.

@param idx The agent index. [Limits: 0
<
= value
<
#getAgentCount()]
@param params The new agent configuration.

public void updateAgentParameters(int const idx, dtCrowdAgentParams const * params)
*/
func (p DtCrowdPtr) UpdateAgentParameters(idx int32, params DtCrowdAgentParamsPtr) {
	var wrap_this unsafe.Pointer
	var wrap_arg_idx C.int
	var wrap_arg_params unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_idx = (C.int)(idx)
	wrap_arg_params = (unsafe.Pointer)(params)
	C.nav_dtCrowd_updateAgentParameters(wrap_this, wrap_arg_idx, wrap_arg_params)
}

/*
Represents an agent managed by a #dtCrowd object.

	crowd
*/
type DtCrowdAgentPtr uintptr

/*
public void Delete()
*/
func (p DtCrowdAgentPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgent_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtCrowdAgentPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgent_DeleteArray(wrap_this)
}

/*
public dtCrowdAgent()
*/
func NewDtCrowdAgent() cgo.GoManagedPtr[DtCrowdAgentPtr] {
	wrap_out := C.nav_NewdtCrowdAgent()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtCrowdAgentPtr]](uintptr(wrap_out))
	return go_out
}

/*
True if the agent is active, false if the agent is in an unused slot in the agent pool.

public bool * GetPtrToActive()
*/
func (p DtCrowdAgentPtr) GetPtrToActive() *bool {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToActive(wrap_this)
	go_out := (*bool)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The local boundary data for the agent.

public dtLocalBoundary * GetPtrToBoundary()
*/
func (p DtCrowdAgentPtr) GetPtrToBoundary() DtLocalBoundaryPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToBoundary(wrap_this)
	go_out := cgo.MakePtr[DtLocalBoundaryPtr](uintptr(wrap_out))
	return go_out
}

/*
The local path corridor corner flags. (See: #dtStraightPathFlags) [(flags) * #ncorners]

public unsigned char(*)[4] GetPtrToCornerFlags()
*/
func (p DtCrowdAgentPtr) GetPtrToCornerFlags() *[4]uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToCornerFlags(wrap_this)
	go_out := (*[4]uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The reference id of the polygon being entered at the corner. [(polyRef) * #ncorners]

public dtPolyRef(*)[4] GetPtrToCornerPolys()
*/
func (p DtCrowdAgentPtr) GetPtrToCornerPolys() *[4]uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToCornerPolys(wrap_this)
	go_out := (*[4]uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The local path corridor corners for the agent. (Staight path.) [(x, y, z) * #ncorners]

public float(*)[12] GetPtrToCornerVerts()
*/
func (p DtCrowdAgentPtr) GetPtrToCornerVerts() *[12]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToCornerVerts(wrap_this)
	go_out := (*[12]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The path corridor the agent is using.

public dtPathCorridor * GetPtrToCorridor()
*/
func (p DtCrowdAgentPtr) GetPtrToCorridor() DtPathCorridorPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToCorridor(wrap_this)
	go_out := cgo.MakePtr[DtPathCorridorPtr](uintptr(wrap_out))
	return go_out
}

/*
The desired speed.

public float * GetPtrToDesiredSpeed()
*/
func (p DtCrowdAgentPtr) GetPtrToDesiredSpeed() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToDesiredSpeed(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
A temporary value used to accumulate agent displacement during iterative collision resolution. [(x, y, z)]

public float(*)[3] GetPtrToDisp()
*/
func (p DtCrowdAgentPtr) GetPtrToDisp() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToDisp(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The desired velocity of the agent. Based on the current path, calculated from scratch each frame. [(x, y, z)]

public float(*)[3] GetPtrToDvel()
*/
func (p DtCrowdAgentPtr) GetPtrToDvel() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToDvel(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of corners.

public int * GetPtrToNcorners()
*/
func (p DtCrowdAgentPtr) GetPtrToNcorners() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToNcorners(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The known neighbors of the agent.

public dtCrowdNeighbour(*)[6] GetPtrToNeis()
*/
func (p DtCrowdAgentPtr) GetPtrToNeis() DtCrowdNeighbourPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToNeis(wrap_this)
	go_out := cgo.MakePtr[DtCrowdNeighbourPtr](uintptr(wrap_out))
	return go_out
}

/*
The number of neighbors.

public int * GetPtrToNneis()
*/
func (p DtCrowdAgentPtr) GetPtrToNneis() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToNneis(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The current agent position. [(x, y, z)]

public float(*)[3] GetPtrToNpos()
*/
func (p DtCrowdAgentPtr) GetPtrToNpos() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToNpos(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The desired velocity adjusted by obstacle avoidance, calculated from scratch each frame. [(x, y, z)]

public float(*)[3] GetPtrToNvel()
*/
func (p DtCrowdAgentPtr) GetPtrToNvel() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToNvel(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The agent's configuration parameters.

public dtCrowdAgentParams * GetPtrToParams()
*/
func (p DtCrowdAgentPtr) GetPtrToParams() DtCrowdAgentParamsPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToParams(wrap_this)
	go_out := cgo.MakePtr[DtCrowdAgentParamsPtr](uintptr(wrap_out))
	return go_out
}

/*
True if the agent has valid path (targetState == DT_CROWDAGENT_TARGET_VALID) and the path does not lead to the requested position, else false.

public bool * GetPtrToPartial()
*/
func (p DtCrowdAgentPtr) GetPtrToPartial() *bool {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToPartial(wrap_this)
	go_out := (*bool)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The type of mesh polygon the agent is traversing. (See: #CrowdAgentState)

public unsigned char * GetPtrToState()
*/
func (p DtCrowdAgentPtr) GetPtrToState() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToState(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Path finder ref.

public dtPathQueueRef * GetPtrToTargetPathqRef()
*/
func (p DtCrowdAgentPtr) GetPtrToTargetPathqRef() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToTargetPathqRef(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Target position of the movement request (or velocity in case of DT_CROWDAGENT_TARGET_VELOCITY).

public float(*)[3] GetPtrToTargetPos()
*/
func (p DtCrowdAgentPtr) GetPtrToTargetPos() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToTargetPos(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Target polyref of the movement request.

public dtPolyRef * GetPtrToTargetRef()
*/
func (p DtCrowdAgentPtr) GetPtrToTargetRef() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToTargetRef(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Flag indicating that the current path is being replanned.

public bool * GetPtrToTargetReplan()
*/
func (p DtCrowdAgentPtr) GetPtrToTargetReplan() *bool {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToTargetReplan(wrap_this)
	go_out := (*bool)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToTargetReplanTime()
*/
func (p DtCrowdAgentPtr) GetPtrToTargetReplanTime() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToTargetReplanTime(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
State of the movement request.

public unsigned char * GetPtrToTargetState()
*/
func (p DtCrowdAgentPtr) GetPtrToTargetState() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToTargetState(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Time since the agent's path corridor was optimized.

public float * GetPtrToTopologyOptTime()
*/
func (p DtCrowdAgentPtr) GetPtrToTopologyOptTime() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToTopologyOptTime(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The actual velocity of the agent. The change from nvel -> vel is constrained by max acceleration. [(x, y, z)]

public float(*)[3] GetPtrToVel()
*/
func (p DtCrowdAgentPtr) GetPtrToVel() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_GetPtrToVel(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtCrowdAgent * IndexArray(long n)
*/
func (p DtCrowdAgentPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgent_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtCrowdAgentAnimationPtr uintptr

/*
public void Delete()
*/
func (p DtCrowdAgentAnimationPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgentAnimation_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtCrowdAgentAnimationPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgentAnimation_DeleteArray(wrap_this)
}

/*
public dtCrowdAgentAnimation()
*/
func NewDtCrowdAgentAnimation() cgo.GoManagedPtr[DtCrowdAgentAnimationPtr] {
	wrap_out := C.nav_NewdtCrowdAgentAnimation()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtCrowdAgentAnimationPtr]](uintptr(wrap_out))
	return go_out
}

/*
public bool * GetPtrToActive()
*/
func (p DtCrowdAgentAnimationPtr) GetPtrToActive() *bool {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_GetPtrToActive(wrap_this)
	go_out := (*bool)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToEndPos()
*/
func (p DtCrowdAgentAnimationPtr) GetPtrToEndPos() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_GetPtrToEndPos(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToInitPos()
*/
func (p DtCrowdAgentAnimationPtr) GetPtrToInitPos() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_GetPtrToInitPos(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public dtPolyRef * GetPtrToPolyRef()
*/
func (p DtCrowdAgentAnimationPtr) GetPtrToPolyRef() *uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_GetPtrToPolyRef(wrap_this)
	go_out := (*uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToStartPos()
*/
func (p DtCrowdAgentAnimationPtr) GetPtrToStartPos() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_GetPtrToStartPos(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToT()
*/
func (p DtCrowdAgentAnimationPtr) GetPtrToT() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_GetPtrToT(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float * GetPtrToTmax()
*/
func (p DtCrowdAgentAnimationPtr) GetPtrToTmax() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_GetPtrToTmax(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtCrowdAgentAnimation * IndexArray(long n)
*/
func (p DtCrowdAgentAnimationPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentAnimation_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

type DtCrowdAgentDebugInfoPtr uintptr

/*
public void Delete()
*/
func (p DtCrowdAgentDebugInfoPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgentDebugInfo_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtCrowdAgentDebugInfoPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgentDebugInfo_DeleteArray(wrap_this)
}

/*
public dtCrowdAgentDebugInfo()
*/
func NewDtCrowdAgentDebugInfo() cgo.GoManagedPtr[DtCrowdAgentDebugInfoPtr] {
	wrap_out := C.nav_NewdtCrowdAgentDebugInfo()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtCrowdAgentDebugInfoPtr]](uintptr(wrap_out))
	return go_out
}

/*
public int * GetPtrToIdx()
*/
func (p DtCrowdAgentDebugInfoPtr) GetPtrToIdx() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentDebugInfo_GetPtrToIdx(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToOptEnd()
*/
func (p DtCrowdAgentDebugInfoPtr) GetPtrToOptEnd() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentDebugInfo_GetPtrToOptEnd(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public float(*)[3] GetPtrToOptStart()
*/
func (p DtCrowdAgentDebugInfoPtr) GetPtrToOptStart() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentDebugInfo_GetPtrToOptStart(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
public dtObstacleAvoidanceDebugData * * GetPtrToVod()
*/
func (p DtCrowdAgentDebugInfoPtr) GetPtrToVod() *DtObstacleAvoidanceDebugDataPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentDebugInfo_GetPtrToVod(wrap_this)
	go_out := (*DtObstacleAvoidanceDebugDataPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtCrowdAgentDebugInfo * IndexArray(long n)
*/
func (p DtCrowdAgentDebugInfoPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentDebugInfo_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Configuration parameters for a crowd agent.

	crowd
*/
type DtCrowdAgentParamsPtr uintptr

/*
public void Delete()
*/
func (p DtCrowdAgentParamsPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgentParams_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtCrowdAgentParamsPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdAgentParams_DeleteArray(wrap_this)
}

/*
public dtCrowdAgentParams()
*/
func NewDtCrowdAgentParams() cgo.GoManagedPtr[DtCrowdAgentParamsPtr] {
	wrap_out := C.nav_NewdtCrowdAgentParams()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtCrowdAgentParamsPtr]](uintptr(wrap_out))
	return go_out
}

/*
Defines how close a collision element must be before it is considered for steering behaviors. [Limits: > 0]

public float * GetPtrToCollisionQueryRange()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToCollisionQueryRange() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToCollisionQueryRange(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Agent height. [Limit: > 0]

public float * GetPtrToHeight()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToHeight() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToHeight(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Maximum allowed acceleration. [Limit: >= 0]

public float * GetPtrToMaxAcceleration()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToMaxAcceleration() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToMaxAcceleration(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Maximum allowed speed. [Limit: >= 0]

public float * GetPtrToMaxSpeed()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToMaxSpeed() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToMaxSpeed(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The index of the avoidance configuration to use for the agent.
[Limits: 0
<
= value
<
= #DT_CROWD_MAX_OBSTAVOIDANCE_PARAMS]

public unsigned char * GetPtrToObstacleAvoidanceType()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToObstacleAvoidanceType() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToObstacleAvoidanceType(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The path visibility optimization range. [Limit: > 0]

public float * GetPtrToPathOptimizationRange()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToPathOptimizationRange() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToPathOptimizationRange(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The index of the query filter used by this agent.

public unsigned char * GetPtrToQueryFilterType()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToQueryFilterType() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToQueryFilterType(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Agent radius. [Limit: >= 0]

public float * GetPtrToRadius()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToRadius() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToRadius(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
How aggresive the agent manager should be at avoiding collisions with this agent. [Limit: >= 0]

public float * GetPtrToSeparationWeight()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToSeparationWeight() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToSeparationWeight(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Flags that impact steering behavior. (See: #UpdateFlags)

public unsigned char * GetPtrToUpdateFlags()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToUpdateFlags() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToUpdateFlags(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
User defined data attached to the agent.

public void * * GetPtrToUserData()
*/
func (p DtCrowdAgentParamsPtr) GetPtrToUserData() *uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_GetPtrToUserData(wrap_this)
	go_out := (*uintptr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtCrowdAgentParams * IndexArray(long n)
*/
func (p DtCrowdAgentParamsPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdAgentParams_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Provides neighbor data for agents managed by the crowd.

	crowd

@see dtCrowdAgent::neis, dtCrowd
*/
type DtCrowdNeighbourPtr uintptr

/*
public void Delete()
*/
func (p DtCrowdNeighbourPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdNeighbour_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p DtCrowdNeighbourPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_dtCrowdNeighbour_DeleteArray(wrap_this)
}

/*
public dtCrowdNeighbour()
*/
func NewDtCrowdNeighbour() cgo.GoManagedPtr[DtCrowdNeighbourPtr] {
	wrap_out := C.nav_NewdtCrowdNeighbour()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[DtCrowdNeighbourPtr]](uintptr(wrap_out))
	return go_out
}

/*
The distance between the current agent and the neighbor.

public float * GetPtrToDist()
*/
func (p DtCrowdNeighbourPtr) GetPtrToDist() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdNeighbour_GetPtrToDist(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The index of the neighbor in the crowd.

public int * GetPtrToIdx()
*/
func (p DtCrowdNeighbourPtr) GetPtrToIdx() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdNeighbour_GetPtrToIdx(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
dtCrowdNeighbour * IndexArray(long n)
*/
func (p DtCrowdNeighbourPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_dtCrowdNeighbour_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Allocates a crowd object using the Detour allocator.

@return A crowd object that is ready for initialization, or null on failure.

	crowd

dtCrowd * dtAllocCrowd()
*/
func DtAllocCrowd() DtCrowdPtr {
	wrap_out := C.nav_dtAllocCrowd()
	go_out := cgo.MakePtr[DtCrowdPtr](uintptr(wrap_out))
	return go_out
}

/*
Frees the specified crowd object using the Detour allocator.

@param ptr A crowd object allocated using #dtAllocCrowd

	crowd

void dtFreeCrowd(dtCrowd * ptr)
*/
func DtFreeCrowd(ptr DtCrowdPtr) {
	var wrap_arg_ptr unsafe.Pointer
	wrap_arg_ptr = (unsafe.Pointer)(ptr)
	C.nav_dtFreeCrowd(wrap_arg_ptr)
}

/*
dtCrowdAgentAnimation * NewDtCrowdAgentAnimationPtrArray(long n)
*/
func NewDtCrowdAgentAnimationPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtCrowdAgentAnimationPtr]] {
	wrap_out := C.nav_NewDtCrowdAgentAnimationPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtCrowdAgentAnimationPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtCrowdAgentDebugInfo * NewDtCrowdAgentDebugInfoPtrArray(long n)
*/
func NewDtCrowdAgentDebugInfoPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtCrowdAgentDebugInfoPtr]] {
	wrap_out := C.nav_NewDtCrowdAgentDebugInfoPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtCrowdAgentDebugInfoPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtCrowdAgentParams * NewDtCrowdAgentParamsPtrArray(long n)
*/
func NewDtCrowdAgentParamsPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtCrowdAgentParamsPtr]] {
	wrap_out := C.nav_NewDtCrowdAgentParamsPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtCrowdAgentParamsPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtCrowdAgent * NewDtCrowdAgentPtrArray(long n)
*/
func NewDtCrowdAgentPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtCrowdAgentPtr]] {
	wrap_out := C.nav_NewDtCrowdAgentPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtCrowdAgentPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtCrowdNeighbour * NewDtCrowdNeighbourPtrArray(long n)
*/
func NewDtCrowdNeighbourPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtCrowdNeighbourPtr]] {
	wrap_out := C.nav_NewDtCrowdNeighbourPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtCrowdNeighbourPtr]]](uintptr(wrap_out))
	return go_out
}

/*
dtCrowd * NewDtCrowdPtrArray(long n)
*/
func NewDtCrowdPtrArray(n int) cgo.GoManagedPtr[cgo.Array[DtCrowdPtr]] {
	wrap_out := C.nav_NewDtCrowdPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[DtCrowdPtr]]](uintptr(wrap_out))
	return go_out
}

/*
The type of navigation mesh polygon the agent is currently traversing.

	crowd
*/
type EnumCrowdAgentState uint32

const (
	/*
	   The agent is not in a valid state.
	*/
	EnumCrowdAgentState_DT_CROWDAGENT_STATE_INVALID EnumCrowdAgentState = 0
	/*
	   The agent is traversing a normal navigation mesh polygon.
	*/
	EnumCrowdAgentState_DT_CROWDAGENT_STATE_WALKING EnumCrowdAgentState = 1
	/*
	   The agent is traversing an off-mesh connection.
	*/
	EnumCrowdAgentState_DT_CROWDAGENT_STATE_OFFMESH EnumCrowdAgentState = 2
)

type EnumMoveRequestState uint32

const (
	EnumMoveRequestState_DT_CROWDAGENT_TARGET_NONE              EnumMoveRequestState = 0
	EnumMoveRequestState_DT_CROWDAGENT_TARGET_FAILED            EnumMoveRequestState = 1
	EnumMoveRequestState_DT_CROWDAGENT_TARGET_VALID             EnumMoveRequestState = 2
	EnumMoveRequestState_DT_CROWDAGENT_TARGET_REQUESTING        EnumMoveRequestState = 3
	EnumMoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_QUEUE EnumMoveRequestState = 4
	EnumMoveRequestState_DT_CROWDAGENT_TARGET_WAITING_FOR_PATH  EnumMoveRequestState = 5
	EnumMoveRequestState_DT_CROWDAGENT_TARGET_VELOCITY          EnumMoveRequestState = 6
)

/*
Crowd agent update flags.

	crowd

@see dtCrowdAgentParams::updateFlags
*/
type EnumUpdateFlags uint32

const (
	EnumUpdateFlags_DT_CROWD_ANTICIPATE_TURNS   EnumUpdateFlags = 1
	EnumUpdateFlags_DT_CROWD_OBSTACLE_AVOIDANCE EnumUpdateFlags = 2
	EnumUpdateFlags_DT_CROWD_SEPARATION         EnumUpdateFlags = 4
	/*
	   Use #dtPathCorridor::optimizePathVisibility() to optimize the agent path.
	*/
	EnumUpdateFlags_DT_CROWD_OPTIMIZE_VIS EnumUpdateFlags = 8
	/*
	   Use dtPathCorridor::optimizePathTopology() to optimize the agent path.
	*/
	EnumUpdateFlags_DT_CROWD_OPTIMIZE_TOPO EnumUpdateFlags = 16
)
